package com.softer.chengxin.dongle.service.impl;

import com.softer.chengxin.common.domin.*;
import com.softer.chengxin.common.enums.NumberEnum;
import com.softer.chengxin.common.enums.ResultEnum;
import com.softer.chengxin.corp.dao.CorpDao;
import com.softer.chengxin.corp.domin.Corp;
import com.softer.chengxin.dongle.dao.DongleDao;
import com.softer.chengxin.dongle.domin.DongleInfoDTO;
import com.softer.chengxin.dongle.domin.DongleInfoVO;
import com.softer.chengxin.dongle.service.DongleService;
import com.softer.chengxin.person.domin.PersonVO;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.persistence.criteria.CriteriaBuilder;
import java.util.ArrayList;
import java.util.List;

/**
 * @author Gong Zhiyang
 * @date 2018/9/26
 */
@Service
public class DongleServiceImpl implements DongleService {

    private Logger logger = LoggerFactory.getLogger(DongleServiceImpl.class);
    @Autowired
    private DongleDao dongleDao;
    @Autowired
    private CorpDao corpDao;

    /**
     * 主管部门获取企业自有加密狗设备列表
     *
     * @param id        企业ID
     * @param loginName 登陆账号
     * @return 结果集
     */
    @Override
    public List<DongleInfoVO> loadDongleInfo(Integer id, String loginName) {
        String area = null;
        if (!Common.ADMIN.equals(loginName)) {
            area = corpDao.getDistinct(loginName);
        }
        return dongleDao.loadDongleInfo(id, area);
    }

    /**
     * 加密设备删除
     *
     * @param id 加密狗ID
     * @return 处理结果
     */
    @Override
    public CommonResult deleteDongleInfo(Integer id) {
        try {
            int num = dongleDao.deleteDongleInfo(id);
            if (num > NumberEnum.ZERO.getNum()) {
                return new CommonResult(ResultEnum.SUCCESS.getCode(), "加密锁设备删除成功");
            }
            return new CommonResult(ResultEnum.FAIL.getCode(), "加密锁设备删除失败");
        } catch (Exception e) {
            logger.error("加密设备删除错误", e);
            return new CommonResult(ResultEnum.FAIL.getCode(), "加密锁设备删除失败");
        }
    }

    /**
     * 加密狗设备添加
     *
     * @param dongleInfoDTO 加密狗信息
     * @param loginName     登陆用户
     * @return 添加结果
     */
    @Override
    public CommonResult addDongleInfo(DongleInfoDTO dongleInfoDTO, String loginName) {
        String keyDog = dongleDao.getKeyDogIsBind(dongleInfoDTO.getKeyDog());
        if (StringUtils.isNotBlank(keyDog)) {
            return new CommonResult(ResultEnum.FAIL.getCode(), "该设备已绑定其他企业");
        }
        dongleInfoDTO.setAlloTer(loginName);
        //默认设置为有效
        dongleInfoDTO.setState(Integer.parseInt(Common.ONE));
        int num = dongleDao.addDongleInfo(dongleInfoDTO);
        if (num > Integer.parseInt(Common.ZERO)) {
            return new CommonResult(ResultEnum.SUCCESS.getCode(), "加密狗设备添加成功");
        }
        return new CommonResult(ResultEnum.FAIL.getCode(), "加密狗设备添加失败，请稍后再试");
    }

    /**
     * 修改加密狗状态
     *
     * @param id    令牌号
     * @param state 状态
     * @return 结果
     */
    @Override
    public CommonResult update(Integer id, Integer state) {
        //当启用加密狗时，检测加密狗是否已经绑定其他项目
        if (Integer.parseInt(Common.ONE) == state) {
            //根据ID查询该条的加密狗
            String key = dongleDao.getKey(id);
            if (StringUtils.isBlank(key)) {
                return new CommonResult(ResultEnum.FAIL.getCode(), "未查询到加密狗");
            }
            //检测该加密狗是否绑定其他的生效的项目或企业
            String keyDog = dongleDao.getKeyDog(key);
            if (StringUtils.isNotBlank(keyDog)) {
                return new CommonResult(ResultEnum.FAIL.getCode(), "该加密狗已经绑定其他项目");
            }
        }
        int ret = dongleDao.update(id, state);
        if (ret == 1) {
            return new CommonResult(ResultEnum.SUCCESS.getCode(), "操作成功！");
        }
        return new CommonResult(ResultEnum.FAIL.getCode(), "操作失败！");
    }

    /**
     * 获取企业加密狗设备列表
     *
     * @param page 页面实体
     * @param id   企业Id
     * @return 列表
     */
    @Override
    public ManagerPageResult loadQyDongleInfo(Page page, Integer id) {
        ManagerPageResult mpr = new ManagerPageResult();
        JsonResult jr = new JsonResult();
        try {
            int num = dongleDao.countQyDongleNum(id);
            if (num > Integer.parseInt(Common.ZERO)) {
                List<DongleInfoVO> list = dongleDao.countQyDongleList(page, id);
                setValue(mpr, jr, num, list);
                return mpr;
            }
        } catch (Exception e) {
            logger.error("企业查询加密狗列表错误", e);
        }
        setValue(mpr, jr, Integer.parseInt(Common.ZERO), new ArrayList());
        return mpr;
    }

    /**
     * 主管部门获取加密狗企业列表
     *
     * @param page      页面实体
     * @param name      企业名
     * @param state     状态（1基本信息提交，2已注册备案）
     * @param loginName 登陆账号
     * @return 企业列表
     */
    @Override
    public ManagerPageResult loadCorpList(Page page, String name, Integer state, String loginName) {
        ManagerPageResult mr = new ManagerPageResult();
        JsonResult jr = new JsonResult();
        try {
            //获取登陆账号的管理区域
            String area = corpDao.getDistinct(loginName);
            String states = "0,1,2,3,4";
            if (state != null) {
                if (Integer.parseInt(Common.ONE) == state) {
                    states = "2";
                } else if (Integer.parseInt(Common.TWO) == state) {
                    states = "0,1,3,4";
                }
            }
            int num = dongleDao.loadCorpNum(name, states, area);
            if (num > Integer.parseInt(Common.ZERO)) {
                List<Corp> list = dongleDao.loadCorpList(page, name, states, area);
                setValue(mr, jr, num, list);
                return mr;
            }
        } catch (Exception e) {
            logger.error("主管部门获取机密狗企业列表错误", e);
        }
        setValue(mr, jr, Integer.parseInt(Common.ZERO), new ArrayList());
        return mr;
    }

    /**
     * 企业给项目绑定加密狗时，先校验加密狗
     *
     * @param code 加密狗
     * @return 校验结果
     */
    @Override
    public CommonResult check(String code) {
        if (StringUtils.isBlank(code)){
            return new CommonResult(ResultEnum.FAIL.getCode(), "请插入加密设备");
        }
        String keyDog = dongleDao.getKeyDogIsBind(code);
        if (StringUtils.isNotBlank(keyDog)) {
            return new CommonResult(ResultEnum.FAIL.getCode(), "该设备已绑定");
        }
        return new CommonResult(ResultEnum.SUCCESS.getCode(),"未发现加密狗，可以添加");
    }

    /**
     * 主管部门的严重负面信息页面加载
     * 调用该方法设置传参
     *
     * @param mpr  响应结果
     * @param jr    Json结果集
     * @param count 数量
     * @param list  信息集合
     */
    private void setValue(ManagerPageResult mpr, JsonResult jr, Integer count, List list) {
        mpr.setCount(count);
        jr.setDs(list);
        mpr.setJson(jr);
    }
}
